home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / BEERSRC.ZIP / GAMEPLAY.C < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-27  |  10.5 KB  |  420 lines
  1.  
  2. //  [c] copyright 1992, 1993 by ALPHA-HELIX.
  3. //  written by Dany Schoch
  4.  
  5. #include <stdio.h>
  6. #include <string.h>
  7. #include <errno.h>
  8.  
  9. #include "xmode.h"
  10. #include "fileman.h"
  11. #include "sound.h"
  12. #include "baller.h"
  13.  
  14.  
  15. #define STARTLOGOX        68
  16. #define STARTLOGOY        110
  17. #define STARTTEXTY        40
  18. #define WINTEXTY        204
  19.  
  20. // Where's the bottle at the beginning ?
  21. #define    XSTART            150
  22. #define    YSTART            190
  23.  
  24.  
  25. // Variables local to this module.
  26.  
  27. static struct sprstrc *scorebar;
  28. static struct sprstrc *barfont;
  29.  
  30.  
  31. /*------------------------------------------------------
  32. Function: newgame
  33.  
  34. Description: Initializes variables, sprites and
  35.          whatsoever needed for a brand new game.
  36. ------------------------------------------------------*/
  37.  
  38. static void newgame(void)
  39. {
  40.    int   i;            // Just another boring index variable.
  41.    int   *ptr;
  42.  
  43.    killallbuddies();
  44.    killallsprites();
  45.    killallobjects();
  46.    killstarfield();
  47.  
  48.    intindexptr = ptrindexptr = 0;    // Reset index table counters.
  49.  
  50. // Load weapon characteristics.
  51.    ptr = loadfile(datapool, "weapons.wpn");
  52.    weapon.narms = *ptr;
  53.    weapon.arm = (struct armstrc *)(ptr+1);
  54.  
  55. // Load shot pathes.
  56.    ptr = loadfile(datapool, "weapons.sht");
  57.    weapon.nshots = *ptr;
  58.    weapon.shot = (struct shotstrc * far *)(ptr+1);
  59.    for (i = 0; i < weapon.nshots; i++) {
  60.       (long)weapon.shot[i] += (long)weapon.shot;
  61.    }
  62.  
  63. // Load weapon sprite library.
  64.    ptr = loadfile(datapool, "weapons.sli");
  65.    weapon.nsprites = *ptr;
  66.    weapon.sprite = (struct sTableEntry *)(ptr+1);
  67.    for (i = 0; i < weapon.nsprites; i++) {
  68.       (long)weapon.sprite[i].sprite += (long)weapon.sprite;
  69.    }
  70.  
  71. // Define Weaponsprites and store reference number in 'intindex'.
  72.    for (i = 0; i < weapon.nsprites; i++) {
  73.       if ((intindex[intindexptr++] =
  74.       defsprite(weapon.sprite[i].sprite, weapon.sprite[i].flags)) == -1)
  75.      error("newgame1", ENOMEM);
  76.    }
  77. // Sprites are defined and copied to offscreen memory.
  78. // So we needn't waste main memory by keeping a unecessary copy.
  79.    ptr = (int *)weapon.sprite;
  80.    unloadfile(ptr-1);
  81.  
  82. // Store explosion reference in 'intindex'.
  83.    for (i = 0; i < weapon.nshots; i++) {
  84.       ptrindex[ptrindexptr++] = weapon.shot[i];
  85.    }
  86.  
  87. // Score Bar definition.
  88.    scorebar = loadfile(datapool, "bar.spr");
  89.    barfont = loadfile(datapool, "barfont.spr");
  90.    if ((barfonthandle = defsprite(barfont, 2)) == -1)
  91.       error ("newgame2", ENOMEM);
  92.    unloadfile(barfont);
  93.  
  94. // Lall variables initializaton.
  95.    score = scoreold = 0;
  96.    money = 0;
  97.    shipspeed = STARTSHIPSPEED;
  98.    lifes = STARLIFES;
  99.    stage = 0;
  100.  
  101. // Main weapon definition.
  102.    nweapons = 1;                // First we have 1 weapon.
  103.    weaponlst[0].dx = weaponlst[0].dy = 0;       // At origin (0,0).
  104.    weaponlst[0].arm = weapon.arm[0];
  105. /*
  106. // level 1: Weapon definition during level design.
  107.    shipspeed = 6;
  108.    nweapons += 1;
  109.    weaponlst[1].dx = -18; weaponlst[1].dy = 8;
  110.    weaponlst[1].arm = weapon.arm[1];
  111. */
  112. /*
  113. // level 2: Weapon definition during level design.
  114.    shipspeed = 6;
  115.    nweapons += 2;
  116.    weaponlst[1].dx = -16; weaponlst[1].dy = 6;
  117.    weaponlst[1].arm = weapon.arm[1];
  118.    weaponlst[2].dx = 16; weaponlst[2].dy = 6;
  119.    weaponlst[2].arm = weapon.arm[4];
  120. */
  121. /*
  122. // level 3: Weapon definition during level design.
  123.    shipspeed = 6;
  124.    nweapons += 4;
  125.    weaponlst[1].dx = -16; weaponlst[1].dy = 6;
  126.    weaponlst[1].arm = weapon.arm[1];
  127.    weaponlst[2].dx = 16; weaponlst[2].dy = 6;
  128.    weaponlst[2].arm = weapon.arm[4];
  129.    weaponlst[3].dx = 30; weaponlst[3].dy = 8;
  130.    weaponlst[3].arm = weapon.arm[8];
  131.    weaponlst[4].dx = 0; weaponlst[4].dy = 32;
  132.    weaponlst[4].arm = weapon.arm[6];
  133. */
  134. /*
  135. // level 4: Weapon definition during level design.
  136.    shipspeed = 6;
  137.    nweapons += 6;
  138.    weaponlst[1].dx = -20; weaponlst[1].dy = 8;
  139.    weaponlst[1].arm = weapon.arm[8];
  140.    weaponlst[2].dx = 30; weaponlst[2].dy = 8;
  141.    weaponlst[2].arm = weapon.arm[8];
  142.    weaponlst[3].dx = 0; weaponlst[3].dy = -18;
  143.    weaponlst[3].arm = weapon.arm[5];
  144.    weaponlst[4].dx = 0; weaponlst[4].dy = 32;
  145.    weaponlst[4].arm = weapon.arm[6];
  146.    weaponlst[5].dx = -36; weaponlst[5].dy = 6;
  147.    weaponlst[5].arm = weapon.arm[4];
  148.    weaponlst[6].dx = 16; weaponlst[6].dy = 6;
  149.    weaponlst[6].arm = weapon.arm[1];
  150. */
  151. }
  152.  
  153. static void shutnewgame(void)
  154. {
  155.    int   *ptr;
  156.  
  157.    killallsprites();
  158.    unloadfile(scorebar);
  159.    ptr = (int *)weapon.shot;
  160.    unloadfile(ptr-1);
  161.    ptr = (int *)weapon.arm;
  162.    unloadfile(ptr-1);
  163. }
  164.  
  165.  
  166. static void showstartlogo(char *text)
  167. {
  168.    struct sprstrc *logo;
  169.    struct sprstrc *font;
  170.    struct sndstrc *snd;
  171.  
  172.    clearscreen();
  173.    while(pressedkeys);
  174.  
  175.    logo = loadfile(datapool, "go.spr");
  176.    font = loadfile(datapool, "font3.spr");
  177.    snd  = loadfile(datapool, "go.snd");
  178.    playsample(snd);
  179.    putspritedirect(logo, STARTLOGOX, STARTLOGOY, 0);
  180.    writetext(XMAX/2-strlen(text)*font->xs/2, STARTTEXTY, text, font);
  181.  
  182.    while(!pressedkeys);
  183.  
  184.    haltsound();
  185.    unloadfile(snd);
  186.    unloadfile(font);
  187.    unloadfile(logo);
  188.  
  189. }
  190.  
  191. static void showwinpic(void)
  192. {
  193.    struct sprstrc *font;
  194.    void      *ptr;
  195.  
  196.    while(pressedkeys);
  197.    setvanillapalette(0);
  198.    setpage(0); showpage(0); clearscreen();
  199.    ptr = loadfile(datapool, "sky.pcx");
  200.    showpcx256(ptr, 0);
  201.    unloadfile(ptr);
  202.    font = loadfile(datapool, "font1.spr");
  203.    writetext(40, WINTEXTY, "SORRY. NO HERO TUNE THIS TIME.", font);
  204.    glowin(1);
  205.    unloadfile(font);
  206.  
  207.    while(!pressedkeys);
  208.  
  209.    glowout();
  210.    clearscreen();
  211.    setstandardpalette();
  212. }
  213.  
  214. static void showendlogo(void)
  215. {
  216.    struct sndstrc *snd;
  217.    void   *ptr;
  218.  
  219.    while(pressedkeys);
  220.    setvanillapalette(0);
  221.    setpage(0); showpage(0); clearscreen();
  222.    ptr = loadfile(datapool, "landscap.pcx");
  223.    showpcx256(ptr,5);
  224.    unloadfile(ptr);
  225.    snd = loadfile(datapool, "tod.snd");
  226.    playsample(snd);
  227.    glowin(0);
  228.  
  229.    while(!pressedkeys && soundbusy());
  230.  
  231.    glowout();
  232.    haltsound();
  233.    unloadfile(snd);
  234.    clearscreen();
  235.    setstandardpalette();
  236. }
  237.  
  238.  
  239. /*------------------------------------------------------
  240. Function: initlevel
  241.  
  242. Description: Loads and initializes a new level.
  243. ------------------------------------------------------*/
  244.  
  245. static void initlevel(int stage)
  246. {
  247.    int   i;
  248.    int   *ptr;
  249.    char  levelstr[14], text[14];    // Level filename strings.
  250.  
  251.    sprintf(levelstr, "level%d", stage);
  252.  
  253. // Load Level description.
  254.    strcpy(text, levelstr);
  255.    ptr = loadfile(datapool, strcat(text, ".dsc"));
  256.    level.descript = (struct descrstrc *)ptr;
  257. // Check for wrong level.
  258.    if (level.descript->level != stage) error("initlevel", EINVDAT);
  259.    showstartlogo(level.descript->text);
  260.  
  261. // Load Sprite Library.
  262.    strcpy(text, levelstr);
  263.    ptr = loadfile(datapool, strcat(text, ".sli"));
  264.    level.nsprites = *ptr;
  265.    level.sprite = (struct sTableEntry *)(ptr+1);
  266.    for (i = 0; i < level.nsprites; i++) {
  267.       (long)level.sprite[i].sprite += (long)level.sprite;
  268.    }
  269.  
  270. // Initialize enemy sprites and index tables.
  271.    lsprofs = intindexptr;
  272.    for (i = 0; i < level.nsprites; i++) {
  273.       if ((intindex[intindexptr++] =
  274.       defsprite(level.sprite[i].sprite, level.sprite[i].flags)) == -1)
  275.      error("initlevel", ENOMEM);
  276.    }
  277. // Unload unneeded data.
  278.    ptr = (int *)level.sprite;
  279.    unloadfile(ptr-1);
  280.  
  281. // Load Sound library.
  282.    strcpy(text, levelstr);
  283.    ptr = loadfile(datapool, strcat(text, ".snd"));
  284.    level.nsounds = *ptr;
  285.    level.sound = (struct sndstrc * far *)(ptr+1);
  286.    for (i = 0; i < level.nsounds; i++) {
  287.       (long)level.sound[i] += (long)level.sound;
  288.    }
  289.    lsndofs = ptrindexptr;
  290.    for (i = 0; i < level.nsounds; i++) {
  291.       ptrindex[ptrindexptr++] = level.sound[i];
  292.    }
  293.  
  294. // Load Foe pathes.
  295.    strcpy(text, levelstr);
  296.    ptr = loadfile(datapool, strcat(text, ".foe"));
  297.    level.nfoes = *ptr;
  298.    level.foe = (struct foestrc * far *)(ptr+1);
  299.    for (i = 0; i < level.nfoes; i++) {
  300.       (long)level.foe[i] += (long)level.foe;
  301.    }
  302.    lfoeofs = ptrindexptr;
  303.    for (i = 0; i < level.nfoes; i++) {
  304.       ptrindex[ptrindexptr++] = level.foe[i];
  305.    }
  306.  
  307. // Load Explosions.
  308.    strcpy(text, levelstr);
  309.    ptr = loadfile(datapool, strcat(text, ".exp"));
  310.    level.nexpls = *ptr;
  311.    level.expl = (struct explstrc * far *)(ptr+1);
  312.    for (i = 0; i < level.nexpls; i++) {
  313.       (long)level.expl[i] += (long)level.expl;
  314.    }
  315.    lexplofs = ptrindexptr;
  316.    for (i = 0; i < level.nexpls; i++) {
  317.       ptrindex[ptrindexptr++] = level.expl[i];
  318.    }
  319.  
  320. // Load Attack table.
  321.    strcpy(text, levelstr);
  322.    ptr = loadfile(datapool, strcat(text, ".tbl"));
  323.    level.nattacks = *ptr;
  324.    level.attack = (struct attackstrc *)(ptr+1);
  325.  
  326. // Load Starfield.
  327.    strcpy(text, levelstr);
  328.    ptr = loadfile(datapool, strcat(text, ".sta"));
  329.    level.nstars = *ptr;
  330.    level.star = (struct starstrc *)(ptr+1);
  331.  
  332. // Starfield definition.
  333.    defstarfield(level.nstars, level.star);
  334.    gostarfield();
  335.  
  336. // Add bonus score and money.
  337.    score += level.descript->score;
  338.    money += level.descript->money;
  339.  
  340. }
  341.  
  342.  
  343. static void shutlevel(void)
  344. {
  345.    int   i;
  346.    int   *ptr;
  347.  
  348.    killallbuddies();
  349.    killallobjects();
  350.    killstarfield();
  351.    for (i = 0; i < level.nsprites; i++) {
  352.       killsprite(intindex[i + lsprofs]);
  353.    }
  354.    intindexptr -= level.nsprites;
  355.    ptrindexptr -= (level.nfoes + level.nexpls + level.nsounds);
  356.  
  357.    ptr = (int *)level.sound;
  358.    unloadfile(ptr-1);
  359.    ptr = (int *)level.expl;
  360.    unloadfile(ptr-1);
  361.    ptr = (int *)level.foe;
  362.    unloadfile(ptr-1);
  363.    ptr = (int *)level.attack;
  364.    unloadfile(ptr-1);
  365.    ptr = (int *)level.star;
  366.    unloadfile(ptr-1);
  367. }
  368.  
  369.  
  370.  
  371. static void showplayfield(void)
  372. {
  373.    clearscreen();
  374.    putspritedirect(scorebar, 0, BARY, 0);
  375.    killallobjects();
  376.    killallbuddies();
  377.    setpage(0);
  378.    displifes();
  379.    setpage(1);
  380.    displifes();
  381. }
  382.  
  383.  
  384. void playthegame(void)
  385. {
  386.    int    feedback;
  387.  
  388.    newgame();
  389.  
  390.    do {
  391.       initlevel(stage);
  392.       setplayposition(level.nattacks, level.attack, level.descript->nbigboss);
  393.       do {
  394.      if (!(cheatlevel & CHEATLIFES)) lifes--;
  395.      showplayfield();
  396.      defallarms(XSTART, YSTART);
  397.      feedback = play();
  398.       } while (!feedback && (lifes > 0));
  399.       if (!(cheatlevel & CHEATLIFES)) lifes++;
  400.       shutlevel();
  401.       stage++;
  402.       if (!feedback || (stage == LEVELS)) break;
  403.       weaponmanager();
  404.    } while (1);
  405.  
  406.    shutnewgame();
  407.  
  408. // Check if player has fought through all the levels.
  409.    if (feedback && (stage == LEVELS)) {
  410. // Here we will have the winner code.
  411.       showwinpic();
  412.    } else {
  413. // Here goes the looser code.
  414.       showendlogo();
  415.    }
  416.  
  417.    highscore(TRUE);
  418.  
  419. }
  420.